Go to the documentation of this file.
00001 
00028 using System;
00029 using System.Collections.Generic;
00030 using System.Data;
00031 using System.Data.SqlClient;
00032 using System.Text;
00033 using System.Transactions;
00034 
00035 using RAIS.Common.MessageManagement;
00036 using RAIS.Common.TableManagement;
00037 using RAIS.Common.UserManagement;
00038 using ModificationTypes = System.Collections.Generic.Dictionary<RAIS.Common.MessageManagement.Message.ModificationType, RAIS.Common.MessageManagement.Message.ModificationTypeData>;
00039 using ValidationStatuses = System.Collections.Generic.Dictionary<RAIS.Common.MessageManagement.Message.ValidationStatus, RAIS.Common.MessageManagement.Message.ValidationStatusData>;
00040 using MessageTypes = System.Collections.Generic.Dictionary<RAIS.Common.MessageManagement.Message.MessageType, RAIS.Common.MessageManagement.Message.MessageTypeData>;
00041 using Messages = System.Collections.Generic.Dictionary<int, RAIS.Common.MessageManagement.Message>;
00042 
00043 namespace RAIS.DataAccessLayer
00044 {
00048     public class MessageManagement
00049         {
00050                 //*********************************************************************
00051                 #region Properties
00052 
00059                 public static ModificationTypes ModificationTypes
00060                 {
00061                         get { return GetModificationTypes(); }
00062                 }
00070                 public static ValidationStatuses ValidationStatuses
00071                 {
00072                         get { return GetValidationStatuses(); }
00073                 }
00074                 #endregion
00075                 //*********************************************************************
00076                 #region Constructor
00077                 static MessageManagement()
00078         {
00079                         Message.ModificationTypesDictionary = GetModificationTypes();
00080                         Message.ValidationStatusesDictionary = GetValidationStatuses();
00081                         Message.MessageTypesDictionary = GetMessageTypes();
00082                 }
00083         #endregion
00084                 //*********************************************************************
00085                 #region Public static methods
00086 
00091                 public static Messages GetInputMessagesByUser(UserData user)
00092                 {
00093                         Messages messages = new Messages();
00094 
00095                         using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
00096                         {
00097                                 sqlConnection.Open();
00098 
00099                                 using (SqlCommand sqlCommand = new SqlCommand(Constants.SP_NAME_GetMessagesByUserToID, sqlConnection))
00100                                 {
00101                                         int? validationStatus = null;
00102                                         int? userID = null;
00103                                         int? messageType = Message.MessageTypesDictionary[Message.MessageType.Validation].ID;
00104 
00105                                         if (user.FunctionalRole.Type == FunctionRole.FunctionRoleType.Administrator)
00106                                         {
00107                                                 if (user.Validator)
00108                                                         messageType = null;
00109                                                 else
00110                                                         messageType = Message.MessageTypesDictionary[Message.MessageType.AccountRequest].ID;
00111                                         }
00112 
00113                                         if (user.Validator || user.FunctionalRole.Type == FunctionRole.FunctionRoleType.Administrator)
00114                                                 validationStatus = MessageManagement.ValidationStatuses[Message.ValidationStatus.NotValidated].ID;
00115                                         else
00116                                                 userID = user.ID;
00117 
00118                                         sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
00119                                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_UserToID, userID);
00120                                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_MessageTypeID, messageType);
00121                                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_ValidationStatusID, validationStatus);
00122 
00123                                         using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
00124                                         {
00125                                                 while (sqlReader.Read())
00126                                                 {
00127                                                         Message message = new Message(sqlReader);
00128                             
00129                                                         messages.Add(message.ID, message);
00130                                                 }
00131 
00132                         // check if destination user has restrictions, and if yes, check if they are met
00133                         // needs to be put in stored prozedure
00134                         List<int> messagesToRemove = new List<int>();
00135                         foreach (Message m in messages.Values)
00136                         {
00137                             // check if a user with no restrictions was taken over, thus this user has access to everything
00138                             List<UserAssignment> uas = RAIS.DataAccessLayer.UserManagement.GetUserAssignmentsForUser(user, m.TimeStamp);
00139 
00140                             // get MessageboxRestrictions of Target User, otherwise no filtering
00141                             List<MessageBoxRestriction> userToRestrictions = RAIS.DataAccessLayer.UserManagement.getAllActiveMessageBoxRestrictionsForUser(user, m.TimeStamp);
00142                             // also no filtering for account request messages
00143                             if (((userToRestrictions != null && userToRestrictions.Count > 0) || CheckUserAssignments(uas, m.TimeStamp)) && m.Type != Message.MessageType.AccountRequest)
00144                             {
00145                                 // If Source Users has a DataRole, retrieve it
00146                                 DataRole userFromDataRole = RAIS.DataAccessLayer.UserManagement.GetUserData(m.UserFromName).DataRole;
00147 
00148                                 bool hasRights = false;
00149 
00150                                 if (userFromDataRole != null)
00151                                 {
00152                                     hasRights = CheckRestrictionsByDataRole(userToRestrictions, userFromDataRole, user, RAIS.DataAccessLayer.UserManagement.GetUserData(m.UserFromName), m.TimeStamp);
00153                                 }
00154                                 else
00155                                 {
00156                                     // otherwise source user, has to have an assigned Facility
00157                                     Facility fac = RAIS.DataAccessLayer.UserManagement.GetUserData(m.UserFromName).Facility;
00158                                     hasRights = CheckRestrictionsByFacility(userToRestrictions, fac, user, m.TimeStamp);
00159                                 }
00160 
00161                                 if (!hasRights)
00162                                 {
00163                                     messagesToRemove.Add(m.ID);
00164                                 }
00165 
00166                             }
00167                             else
00168                             {
00169                                 // the user wont get all messages as long as he has any restrictions assigned to him, even if they're not active at the moment
00170                                 userToRestrictions = RAIS.DataAccessLayer.UserManagement.getAllActiveMessageBoxRestrictionsForUser(user);
00171                                 if (userToRestrictions != null && userToRestrictions.Count > 0)
00172                                     messagesToRemove.Add(m.ID);
00173                             }
00174                         } // end of message loop
00175 
00176                         foreach (int i in messagesToRemove)
00177                         {
00178                             messages.Remove(i);
00179                         }
00180                                         }
00181                                 }
00182                         }
00183                         return messages;
00184                 }
00185 
00186         public static List<Facility> getAllowedFacilitiesForRestriction(MessageBoxRestriction mbr, UserData user)
00187         {
00188             List<Facility> facs = new List<Facility>();
00189 
00190             using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
00191             {
00192                 sqlConnection.Open();
00193                 using (SqlCommand sqlCommand = new SqlCommand(Constants.SP_NAME_GetAllowedFacilityForRestrictionWithoutFunction, sqlConnection))
00194                 {
00195 
00196                     sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
00197                     DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_UserID, user.ID);
00198                     if(mbr.Region != null)
00199                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_RegionID, mbr.Region.ID);
00200                     else
00201                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_RegionID, DBNull.Value);
00202                     if (mbr.District != null && !mbr.DistrictName.Equals(RAIS.Common.Constants.ALL_DISTRICTS))
00203                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_DistrictID, mbr.District.ID);
00204                     else
00205                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_DistrictID, DBNull.Value);
00206                     if(mbr.Practice != null)
00207                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_PracticeID, mbr.Practice.ID);
00208                     else
00209                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_PracticeID, DBNull.Value);
00210 
00211                     using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
00212                     {
00213                         while (sqlReader.Read())
00214                         {
00215                             Facility f = new Facility(sqlReader);
00216                             facs.Add(f);
00217                         }
00218                     }
00219                 }
00220             }
00221 
00222             return facs;
00223         }
00224 
00225         public static List<Facility> getAllowedFacilitiesForRestriction(DataRoleAttribute dra, UserData user)
00226         {
00227             List<Facility> facs = new List<Facility>();
00228 
00229             using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
00230             {
00231                 sqlConnection.Open();
00232                 using (SqlCommand sqlCommand = new SqlCommand(Constants.SP_NAME_GetAllowedFacilityForRestriction, sqlConnection))
00233                 {
00234 
00235                     sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
00236                     DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_UserID, user.ID);
00237                     if (dra.Region != null)
00238                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_RegionID, dra.Region.ID);
00239                     else
00240                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_RegionID, DBNull.Value);
00241                     if (dra.District != null && !dra.DistrictName.Equals(RAIS.Common.Constants.ALL_DISTRICTS))
00242                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_DistrictID, dra.District.ID);
00243                     else
00244                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_DistrictID, DBNull.Value);
00245                     
00246                     DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_PracticeID, DBNull.Value);
00247 
00248                     using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
00249                     {
00250                         while (sqlReader.Read())
00251                         {
00252                             Facility f = new Facility(sqlReader);
00253                             facs.Add(f);
00254                         }
00255                     }
00256                 }
00257             }
00258 
00259             return facs;
00260         }
00261 
00265         private static bool CheckUserAssignments(List<UserAssignment> uas, DateTime messageTime)
00266         {
00267             List<MessageBoxRestriction> rest = null;
00268             foreach (UserAssignment ua in uas)
00269             {
00270                 rest = RAIS.DataAccessLayer.UserManagement.getActiveMessageBoxRestrictionsForUser(ua.TakenOverUser, messageTime);
00271                 if (rest != null && rest.Count > 0)
00272                 {
00273                     return true;
00274                 }
00275             }
00276             return false;
00277         }
00278 
00279         private static bool CheckRestrictionsByFacility(List<MessageBoxRestriction> mbrsToCheck, Facility facility, UserData user, DateTime messageDate)
00280         {
00281             Region region = DataAccessLayer.UserManagement.GetRegionForFacility(facility);
00282 
00283             // if region is null, data is corrupt, dont include message
00284             // UPDATE: this is apparantly not the case => removed check
00285             // if (region == null)
00286             //   return false;
00287 
00288             foreach (MessageBoxRestriction mbr in mbrsToCheck)
00289             {
00290                 if (mbr.ValidFrom <= messageDate && messageDate <= mbr.ValidUntil)
00291                 {
00292                     List<Facility> allowedFacilites = getAllowedFacilitiesForRestriction(mbr, user);
00293 
00294                     if (mbr.Facility != null)
00295                     {
00296                         if (!(mbr.Facility.Name.Equals(RAIS.Common.Constants.ALL_FACILITIES) ||
00297                             mbr.Facility.Name.Equals(RAIS.Common.Constants.ALL_FACILITIES_UNKNOWN)))
00298                         {
00299                             allowedFacilites.Clear();
00300                             allowedFacilites.Add(mbr.Facility);
00301                         }
00302                         else if(mbr.Practice != null)
00303                         {
00304                             allowedFacilites.AddRange(RAIS.DataAccessLayer.UserManagement.getFacilitiesByPractice(mbr.Practice.ID));
00305                         }
00306                     }
00307 
00308                     foreach (Facility allowedFac in allowedFacilites)
00309                     {
00310                         if (allowedFac.ID == facility.ID || (allowedFac.Name.Equals(RAIS.Common.Constants.ALL_FACILITIES) ||
00311                             allowedFac.Name.Equals(RAIS.Common.Constants.ALL_FACILITIES_UNKNOWN)))
00312                             return true;
00313                     }
00314                 }
00315             }
00316                  
00317             return false;
00318         }
00319 
00320         private static bool CheckRestrictionsByDataRole(List<MessageBoxRestriction> mbrsToCheck, DataRole fromDataRole, UserData user, UserData messageUser, DateTime messageDate)
00321         {
00322 
00323             foreach (MessageBoxRestriction mbr in mbrsToCheck)
00324             {
00325                 if (mbr.ValidFrom <= messageDate && messageDate <= mbr.ValidUntil)
00326                 {
00327                     List<Facility> allowedFacilites = getAllowedFacilitiesForRestriction(mbr, user);
00328 
00329                     if (mbr.Facility != null)
00330                     {
00331                         if (!(mbr.Facility.Name.Equals(RAIS.Common.Constants.ALL_FACILITIES) ||
00332                             mbr.Facility.Name.Equals(RAIS.Common.Constants.ALL_FACILITIES_UNKNOWN)))
00333                         {
00334                             allowedFacilites.Clear();
00335                             allowedFacilites.Add(mbr.Facility);
00336                         }
00337                     }
00338 
00339                     foreach (DataRoleAttribute draFrom in fromDataRole.Attributes.Values)
00340                     {
00341                         List<Facility> givenFacilities = getAllowedFacilitiesForRestriction(draFrom, messageUser);
00342 
00343                         if (draFrom.Facility != null)
00344                         {
00345                             if (!(draFrom.Facility.Name.Equals(RAIS.Common.Constants.ALL_FACILITIES) ||
00346                                 draFrom.Facility.Name.Equals(RAIS.Common.Constants.ALL_FACILITIES_UNKNOWN)))
00347                             {
00348                                 givenFacilities.Clear();
00349                                 givenFacilities.Add(draFrom.Facility);
00350                             }
00351                         }
00352 
00353                         foreach (Facility f in allowedFacilites)
00354                         {
00355                             foreach (Facility f2 in givenFacilities)
00356                             {
00357                                 if (f.ID == f2.ID)
00358                                     return true;
00359                             }
00360                         }
00361 
00362                     }
00363                 }
00364             }
00365 
00366             return false;
00367         }
00368 
00374                 public static Message GetOpenAccountRequest(UserData user)
00375                 {
00376                         Message accountRequest = null;
00377 
00378                         using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
00379                         {
00380                                 sqlConnection.Open();
00381 
00382                                 using (SqlCommand sqlCommand = new SqlCommand(Constants.SP_NAME_GetOpenAccountRequestByUserID, sqlConnection))
00383                                 {
00384                                         sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
00385                                         DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_UserID, user.ID);
00386 
00387                                         using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
00388                                         {
00389                                                 sqlReader.Read();
00390 
00391                                                 if (sqlReader.HasRows)
00392                                                 {
00393                                                         accountRequest = new Message(sqlReader);
00394                                                 }
00395                                         }
00396                                 }
00397                         }
00398                         return accountRequest;
00399                 }
00406                 public static bool AddMessage(Message message, ref string returnMessage)
00407                 {
00408                         try
00409                         {
00410                                 using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
00411                                 {
00412                                         sqlConnection.Open();
00413 
00414                                         using (SqlCommand sqlCommand = new SqlCommand(Constants.SP_NAME_AddMessage, sqlConnection))
00415                                         {
00416                                                 sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
00417                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_MessageID, message.ID, ParameterDirection.Output);
00418                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_UserFromID, message.UserFromID);
00419                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_UserToID, message.UserToID);
00420                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_TableID, message.TableID);
00421                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_RowID, message.RowID);
00422                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_Comment, message.Comment);
00423                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_ModificationTypeID, message.ModificationData.ID);
00424                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_ValidationStatusID, message.ValidationData.ID);
00425                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_MessageTypeID, message.TypeData.ID);
00426 
00427                                                 sqlCommand.ExecuteNonQuery();
00428 
00429                                                 message.ID = int.Parse(sqlCommand.Parameters[Constants.SP_PARAMETER_MessageID].Value.ToString());
00430                                         }
00431                                 }
00432                                 returnMessage = RAIS.Common.Messages.MESSAGE_ADDED;
00433                                 return true;
00434                         }
00435                         catch (Exception excep)
00436                         {
00437                 returnMessage = excep.Message + Constants.DATA_BASE_ERROR_MASSAGE;
00438                                 return false;
00439                         }
00440                 }
00447                 public static bool SaveMessage(Message message, ref string returnMessage)
00448                 {
00449                         try
00450                         {
00451                                 using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
00452                                 {
00453                                         sqlConnection.Open();
00454 
00455                                         using (SqlCommand sqlCommand = new SqlCommand(Constants.SP_NAME_UpdateMessage, sqlConnection))
00456                                         {
00457                                                 sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
00458                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_MessageID, message.ID);
00459                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_Comment, message.Comment);
00460                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_ValidationStatusID, message.ValidationData.ID);
00461 
00462                                                 sqlCommand.ExecuteNonQuery();
00463                                         }
00464                                 }
00465                                 returnMessage = RAIS.Common.Messages.MESSAGE_SAVED;
00466                                 return true;
00467                         }
00468                         catch (Exception excep)
00469                         {
00470                 returnMessage = excep.Message + Constants.DATA_BASE_ERROR_MASSAGE;
00471                                 return false;
00472                         }
00473                 }
00480                 public static bool SaveMessageHistoryRowID(int messageID, int historyRowID, ref string returnMessage)
00481                 {
00482                         try
00483                         {
00484                                 using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
00485                                 {
00486                                         sqlConnection.Open();
00487 
00488                                         using (SqlCommand sqlCommand = new SqlCommand(Constants.SP_NAME_UpdateMessageHistoryRowID, sqlConnection))
00489                                         {
00490                                                 sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
00491                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_MessageID, messageID);
00492                                                 DataAccessUtilities.AddParameter(sqlCommand, Constants.SP_PARAMETER_HistoryRowID, historyRowID);
00493 
00494                                                 sqlCommand.ExecuteNonQuery();
00495                                         }
00496                                 }
00497                                 returnMessage = RAIS.Common.Messages.MESSAGE_SAVED;
00498                                 return true;
00499                         }
00500                         catch (Exception excep)
00501                         {
00502                 returnMessage = excep.Message + Constants.DATA_BASE_ERROR_MASSAGE;
00503                                 return false;
00504                         }
00505                 }
00511                 public static ValidationData GetValidationDataByMessage(Message message, UserData user)
00512                 {
00513                         string sqlString = string.Empty;
00514                         ValidationData validationData = new ValidationData();
00515 
00516                         validationData.Message = message;
00517                         validationData.Table = TableManagement.GetTableWithRelatedFieldsByTableID(message.TableID);
00518                         validationData.HistoryTable = TableManagement.GetTableWithRelatedFieldsByTableName(validationData.Table.HistoryTableName);
00519 
00520                         sqlString = GetSelectValidationString(validationData.Table, message.RowID);
00521                         validationData.ValidationDataAdapter = GetDataAdapter(sqlString, validationData.ValidationDataSet);
00522 
00523                         if (validationData.ValidationDataSet.Tables[0].Rows.Count > 0)
00524                         {
00525                                 DataRow validationRow = validationData.ValidationDataSet.Tables[0].Rows[0];
00526                                 validationData.ValidationRowValues =
00527                                         DynamicMaskManagement.FillFieldDataListFromTableRow(validationData.Table, validationRow, true, user.ID);
00528 
00529                                 if (validationData.ValidationDataSet.Tables[0].Rows.Count > 0)
00530                                 {
00531                                         int rowID = 0;
00532                                         if (!(validationData.ValidationDataSet.Tables[0].Rows[0][validationData.Table.ForeignKeyFieldName] is DBNull))
00533                                         {
00534                                                 rowID = (int)validationData.ValidationDataSet.Tables[0].Rows[0][validationData.Table.ForeignKeyFieldName];
00535                                         }
00536                                         string[] sqlStrings = DynamicMaskManagement.GetSelectStrings(validationData.Table, 0, 0, rowID, (rowID == 0));
00537                                         validationData.DataAdapter = 
00538                                                 DynamicMaskManagement.GetDataAdapter(
00539                                                           sqlStrings[(int)DynamicMaskManagement.SelectType.MainSelect]
00540                                                         , sqlStrings[(int)DynamicMaskManagement.SelectType.ForInsert]
00541                                                         , validationData.DataSet);
00542 
00543                                         if (validationData.DataSet.Tables[0].Rows.Count > 0)
00544                                         {
00545                                                 DataRow currentRow = validationData.DataSet.Tables[0].Rows[0];
00546                                                 validationData.CurrentRowValues =
00547                                                         DynamicMaskManagement.FillFieldDataListFromTableRow(validationData.Table, currentRow, false, user.ID);
00548                                         }
00549                                         else
00550                                         {
00551                                                 validationData.CurrentRowValues =
00552                                                         DynamicMaskManagement.FillFieldDataListFromTableRow(validationData.Table, null, false, user.ID);
00553                                         }
00554                                 }
00555                         }
00556 
00557                         if (validationData.Table.WithHistoryValidation)
00558                         {
00559                                 sqlString = GetSelectValidationString(validationData.HistoryTable, message.HistoryRowID);
00560                                 validationData.ValidationHistoryDataAdapter = GetDataAdapter(sqlString, validationData.ValidationHistoryDataSet);
00561 
00562                                 if (validationData.ValidationHistoryDataSet.Tables[0].Rows.Count > 0)
00563                                 {
00564                                         DataRow validationHistoryRow = validationData.ValidationHistoryDataSet.Tables[0].Rows[0];
00565                                         validationData.ValidationHistoryRowValues =
00566                                                 DynamicMaskManagement.FillFieldDataListFromTableRow(validationData.HistoryTable, validationHistoryRow, true, user.ID);
00567 
00568                                         if (validationData.ValidationHistoryDataSet.Tables[0].Rows.Count > 0)
00569                                         {
00570                                                 int rowID = 0;
00571                                                 if (!(validationData.ValidationHistoryDataSet.Tables[0].Rows[0][validationData.HistoryTable.ForeignKeyFieldName] is DBNull))
00572                                                 {
00573                                                         rowID = (int)validationData.ValidationDataSet.Tables[0].Rows[0][validationData.Table.ForeignKeyFieldName];
00574                                                 }
00575                                                 string[] sqlStrings = DynamicMaskManagement.GetSelectStrings(validationData.HistoryTable, 0, 0, rowID, (rowID == 0));
00576                                                 validationData.HistoryDataAdapter =
00577                                                         DynamicMaskManagement.GetDataAdapter(
00578                                                                   sqlStrings[(int)DynamicMaskManagement.SelectType.MainSelect]
00579                                                                 , sqlStrings[(int)DynamicMaskManagement.SelectType.ForInsert]
00580                                                                 , validationData.HistoryDataSet);
00581 
00582                                                 if (validationData.HistoryDataSet.Tables[0].Rows.Count > 0)
00583                                                 {
00584                                                         DataRow currentRow = validationData.HistoryDataSet.Tables[0].Rows[0];
00585                                                         validationData.HistoryRowValues =
00586                                                                 DynamicMaskManagement.FillFieldDataListFromTableRow(validationData.HistoryTable, currentRow, false, user.ID);
00587                                                 }
00588                                                 else
00589                                                 {
00590                                                         validationData.HistoryRowValues =
00591                                                                 DynamicMaskManagement.FillFieldDataListFromTableRow(validationData.HistoryTable, null, false, user.ID);
00592                                                 }
00593                                         }
00594                                 }
00595                         }
00596 
00597                         return validationData;
00598                 }
00603                 public static bool ReleaseChanges(Message message, ref string actionMessage, UserData user)
00604                 {
00605                         try
00606                         {
00607                                 bool isInsertionNeeded = false;
00608                                 bool isDeletionNeeded = false;
00609 
00610                                 ValidationData validationData = GetValidationDataByMessage(message, user);
00611                                 validationData.Message.Validation = Message.ValidationStatus.Released;
00612 
00613                                 if (validationData.Message.Modification == Message.ModificationType.Delete)
00614                                 {
00615                                         validationData.DataSet.Tables[0].Rows[0].Delete();
00616                                 }
00617                                 else
00618                                 {
00619                                         if (validationData.Message.Modification == Message.ModificationType.Add)
00620                                         {
00621                                                 validationData.DataSet.Tables[0].Rows.Add();
00622 
00623                                                 if (validationData.Table.WithHistoryValidation)
00624                                                         validationData.HistoryDataSet.Tables[0].Rows.Add();
00625                                         }
00626 
00627                                         // Fill DataSet values from ValidationDataSet
00628                                         FillDataSetFromValidationDataSet(validationData.CurrentRowValues
00629                                                 , validationData.ValidationRowValues
00630                                                 , validationData.DataSet
00631                                                 , validationData.ValidationDataSet
00632                                                 , ref isInsertionNeeded
00633                                                 , ref isDeletionNeeded);
00634                                         validationData.MultilookupInsertionNeeded = isInsertionNeeded;
00635                                         validationData.MultilookupDeletionNeeded = isDeletionNeeded;
00636 
00637                                         if (validationData.Table.WithHistoryValidation
00638                                                 && validationData.Message.Modification == Message.ModificationType.Add)
00639                                         {
00640                                                 FillDataSetFromValidationDataSet(validationData.HistoryRowValues
00641                                                         , validationData.ValidationHistoryRowValues
00642                                                         , validationData.HistoryDataSet
00643                                                         , validationData.ValidationHistoryDataSet
00644                                                         , ref isInsertionNeeded
00645                                                         , ref isDeletionNeeded);
00646                                                 validationData.HistoryMultilookupInsertionNeeded = isInsertionNeeded;
00647                                                 validationData.HistoryMultilookupDeletionNeeded = isDeletionNeeded;
00648                                         }
00649                                 }
00650 
00651                                 // Set validation status
00652                                 validationData.ValidationDataSet.Tables[0].Rows[0]["FK Validation Status ID"] =
00653                                         MessageManagement.ValidationStatuses[Message.ValidationStatus.Released].ID;
00654 
00655                                 if (validationData.Table.WithHistoryValidation
00656                                         && validationData.Message.Modification == Message.ModificationType.Add)
00657                                 {
00658                                         validationData.ValidationHistoryDataSet.Tables[0].Rows[0]["FK Validation Status ID"] =
00659                                                 MessageManagement.ValidationStatuses[Message.ValidationStatus.Released].ID;
00660                                 }
00661 
00662                                 // Save changes
00663                                 using (TransactionScope ts = new TransactionScope())
00664                                 {
00665                                         string errorMessage = string.Empty;
00666                                         bool success;
00667 
00668                                         success = SaveMessage(validationData.Message, ref errorMessage);
00669                                         if (!success)
00670                                                 throw new Exception(errorMessage);
00671 
00672                                         // Call Update for main table
00673                                         validationData.DataAdapter.Update(validationData.DataSet);
00674 
00675                                         if (validationData.Message.Modification == Message.ModificationType.Add)
00676                                         {
00677                                                 validationData.ValidationDataSet.Tables[0].Rows[0][validationData.Table.ForeignKeyFieldName] =
00678                                                         validationData.DataSet.Tables[0].Rows[0][validationData.Table.PrimaryKeyFieldName];
00679                                         }
00680                 
00681                                         validationData.ValidationDataAdapter.Update(validationData.ValidationDataSet);
00682 
00683                                         if (validationData.MultilookupInsertionNeeded)
00684                                                 InsertMultilookupValues(validationData.Table, validationData.DataSet.Tables[0].Rows[0], validationData.CurrentRowValues);
00685 
00686                                         if (validationData.MultilookupDeletionNeeded)
00687                                                 DeleteMultilookupValues(validationData.Table, validationData.DataSet.Tables[0].Rows[0], validationData.CurrentRowValues);
00688 
00689                                         // Call Update for history table
00690                                         if (validationData.Table.WithHistoryValidation
00691                                                 && validationData.Message.Modification == Message.ModificationType.Add)
00692                                         {
00693                                                 if (validationData.Message.Modification == Message.ModificationType.Add)
00694                                                 {
00695                                                         validationData.HistoryDataSet.Tables[0].Rows[0][validationData.Table.ForeignKeyFieldName] =
00696                                                                 validationData.DataSet.Tables[0].Rows[0][validationData.Table.PrimaryKeyFieldName];
00697                                                 }
00698 
00699                                                 validationData.HistoryDataAdapter.Update(validationData.HistoryDataSet);
00700 
00701                                                 if (validationData.Message.Modification == Message.ModificationType.Add)
00702                                                 {
00703                                                         validationData.ValidationHistoryDataSet.Tables[0].Rows[0][validationData.Table.ForeignKeyFieldName] =
00704                                                                 validationData.DataSet.Tables[0].Rows[0][validationData.Table.PrimaryKeyFieldName];
00705                                                         validationData.ValidationHistoryDataSet.Tables[0].Rows[0][validationData.HistoryTable.ForeignKeyFieldName] =
00706                                                                 validationData.HistoryDataSet.Tables[0].Rows[0][validationData.HistoryTable.PrimaryKeyFieldName];
00707                                                 }
00708                                                 
00709                                                 validationData.ValidationHistoryDataAdapter.Update(validationData.ValidationHistoryDataSet);
00710 
00711                                                 if (validationData.HistoryMultilookupInsertionNeeded)
00712                                                         InsertMultilookupValues(validationData.HistoryTable, validationData.HistoryDataSet.Tables[0].Rows[0], validationData.HistoryRowValues);
00713 
00714                                                 if (validationData.HistoryMultilookupDeletionNeeded)
00715                                                         DeleteMultilookupValues(validationData.HistoryTable, validationData.HistoryDataSet.Tables[0].Rows[0], validationData.HistoryRowValues);
00716                                         }
00717 
00718                                         CreateAnswerMessage(validationData.Message, user);
00719 
00720                                         ts.Complete();
00721                                 }
00722                                 
00723                                 // Create return message
00724                                 switch (validationData.Message.Modification)
00725                                 {
00726                                         case Message.ModificationType.Add:
00727                                                 actionMessage = RAIS.Common.Messages.RECORD_ADDED;
00728                                                 break;
00729                                         case Message.ModificationType.Edit:
00730                                                 actionMessage = RAIS.Common.Messages.CHANGES_SAVED;
00731                                                 break;
00732                                         case Message.ModificationType.Delete:
00733                                                 actionMessage = RAIS.Common.Messages.RECORD_DELETED;
00734                                                 break;
00735                                 }
00736                         }
00737                         catch (Exception exep)
00738                         {
00739                 actionMessage = exep.Message + Constants.DATA_BASE_ERROR_MASSAGE;
00740                                 return false;
00741                         }
00742 
00743                         return true;
00744                 }
00749                 public static bool RejectChanges(Message message, ref string actionMessage, UserData user)
00750                 {
00751                         try
00752                         {
00753                                 ValidationData validationData = GetValidationDataByMessage(message, user);
00754                                 validationData.Message.Validation = Message.ValidationStatus.Rejected;
00755 
00756                                 validationData.ValidationDataSet.Tables[0].Rows[0]["FK Validation Status ID"] =
00757                                         MessageManagement.ValidationStatuses[Message.ValidationStatus.Rejected].ID;
00758 
00759                                 // Save changes
00760                                 using (TransactionScope ts = new TransactionScope())
00761                                 {
00762                                         string errorMessage = "";
00763                                         bool success;
00764 
00765                                         success = SaveMessage(validationData.Message, ref errorMessage);
00766                                         if (!success)
00767                                                 throw new Exception(errorMessage);
00768 
00769                                         validationData.ValidationDataAdapter.Update(validationData.ValidationDataSet);
00770 
00771                                         CreateAnswerMessage(validationData.Message, user);
00772 
00773                                         ts.Complete();
00774                                 }
00775 
00776                                 // Create return message
00777                                 actionMessage = RAIS.Common.Messages.CHANGES_REJECTED;
00778                         }
00779                         catch (Exception exep)
00780                         {
00781                 actionMessage = exep.Message + Constants.DATA_BASE_ERROR_MASSAGE;
00782                                 return false;
00783                         }
00784 
00785                         return true;
00786                 }
00787 
00788                 public static void CreateAnswerMessage(Message validationMessage, UserData validator)
00789                 {
00790                         bool success;
00791                         string errorMessage = "";
00792 
00793                         Message message = new Message();
00794                         message.UserFromID = validator.ID;
00795                         message.UserToID = validationMessage.UserFromID;
00796                         message.TableID = validationMessage.TableID;
00797                         message.RowID = validationMessage.RowID;
00798                         message.Modification = validationMessage.Modification;
00799                         message.Validation = validationMessage.Validation;
00800                         message.Comment = validationMessage.Comment;
00801 
00802                         success = MessageManagement.AddMessage(message, ref errorMessage);
00803                         if (!success)
00804                                 throw new Exception(errorMessage);
00805                 }
00806                 #endregion
00807                 //*********************************************************************
00808                 #region Private static helper functions
00809 
00814                 static ModificationTypes GetModificationTypes()
00815                 {
00816                         ModificationTypes modificationTypes = new ModificationTypes();
00817                         using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
00818                         {
00819                                 sqlConnection.Open();
00820 
00821                                 using (SqlCommand sqlCommand = new SqlCommand(Constants.SP_NAME_GetModificationTypes, sqlConnection))
00822                                 {
00823                                         sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
00824 
00825                                         using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
00826                                         {
00827                                                 while (sqlReader.Read())
00828                                                 {
00829                                                         Message.ModificationTypeData modificationTypeData = new Message.ModificationTypeData(sqlReader);
00830 
00831                                                         Message.ModificationType modificationType;
00832                                                         try
00833                                                         {
00834                                                                 // Next operator throw an exeption if we do not have 
00835                                                                 // element in enum which corresponds to modification type in Modification Type table
00836                                                                 // Catch it and throw exception with more clear message.
00837                                                                 modificationType = modificationTypeData.Type;
00838                                                         }
00839                                                         catch
00840                                                         {
00841                                                                 throw new Exception("Modification type " + modificationTypeData.VisibleName + " exists in DB but does not exist in Enum Message.ModificationType. The running ASP server is not up to date with respect to the DB.");
00842                                                         }
00843 
00844                                                         modificationTypes.Add(modificationType, modificationTypeData);
00845                                                 }
00846 
00847                                                 // We checked that all enum elements exist in [Modification Type] table, 
00848                                                 // so throw an exeption if number of elements in enum does not 
00849                                                 // equal number of elements in [Modification Type] table
00850                                                 if (Enum.GetNames(typeof(Message.ModificationType)).Length != modificationTypes.Count)
00851                                                         throw new Exception("There are modification types which exist in Enum Message.ModificationType but does not exist in DB. The running DB is not up to date with respect to the ASP server.");
00852                                         }
00853                                 }
00854                         }
00855 
00856                         return modificationTypes;
00857                 }
00863                 static ValidationStatuses GetValidationStatuses()
00864                 {
00865                         ValidationStatuses validationStatuses = new ValidationStatuses();
00866                         using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
00867                         {
00868                                 sqlConnection.Open();
00869 
00870                                 using (SqlCommand sqlCommand = new SqlCommand(Constants.SP_NAME_GetValidationStatuses, sqlConnection))
00871                                 {
00872                                         sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
00873 
00874                                         using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
00875                                         {
00876                                                 while (sqlReader.Read())
00877                                                 {
00878                                                         Message.ValidationStatusData validationStatusData = new Message.ValidationStatusData(sqlReader);
00879 
00880                                                         Message.ValidationStatus validationStatus;
00881                                                         try
00882                                                         {
00883                                                                 // Next operator throw an exeption if we do not have 
00884                                                                 // element in enum which corresponds to validation status in Validation Status table
00885                                                                 // Catch it and throw exception with more clear message.
00886                                                                 validationStatus = validationStatusData.Type;
00887                                                         }
00888                                                         catch
00889                                                         {
00890                                                                 throw new Exception("Validation status " + validationStatusData.VisibleName + " exists in DB but does not exist in Enum Message.ValidationStatus. The running ASP server is not up to date with respect to the DB.");
00891                                                         }
00892 
00893                                                         validationStatuses.Add(validationStatus, validationStatusData);
00894                                                 }
00895 
00896                                                 // We checked that all enum elements exist in [Validation Status] table, 
00897                                                 // so throw an exeption if number of elements in enum does not 
00898                                                 // equal number of elements in [Validation Status] table
00899                                                 if (Enum.GetNames(typeof(Message.ValidationStatus)).Length != validationStatuses.Count)
00900                                                         throw new Exception("There are validation statuses which exist in Enum Message.ValidationStatus but does not exist in DB. The running DB is not up to date with respect to the ASP server.");
00901                                         }
00902                                 }
00903                         }
00904 
00905                         return validationStatuses;
00906                 }
00912                 static MessageTypes GetMessageTypes()
00913                 {
00914                         MessageTypes messageTypes = new MessageTypes();
00915                         using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
00916                         {
00917                                 sqlConnection.Open();
00918 
00919                                 using (SqlCommand sqlCommand = new SqlCommand(Constants.SP_NAME_GetMessageTypes, sqlConnection))
00920                                 {
00921                                         sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
00922 
00923                                         using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
00924                                         {
00925                                                 while (sqlReader.Read())
00926                                                 {
00927                                                         Message.MessageTypeData messageTypeData = new Message.MessageTypeData(sqlReader);
00928 
00929                                                         Message.MessageType messageType;
00930                                                         try
00931                                                         {
00932                                                                 // Next operator throw an exeption if we do not have 
00933                                                                 // element in enum which corresponds to message type in Message Type table
00934                                                                 // Catch it and throw exception with more clear message.
00935                                                                 messageType = messageTypeData.Type;
00936                                                         }
00937                                                         catch
00938                                                         {
00939                                                                 throw new Exception("Message type " + messageTypeData.VisibleName + " exists in DB but does not exist in Enum Message.MessageType. The running ASP server is not up to date with respect to the DB.");
00940                                                         }
00941 
00942                                                         messageTypes.Add(messageType, messageTypeData);
00943                                                 }
00944 
00945                                                 // We checked that all enum elements exist in [Message Type] table, 
00946                                                 // so throw an exeption if number of elements in enum does not 
00947                                                 // equal number of elements in [Message Type] table
00948                                                 if (Enum.GetNames(typeof(Message.MessageType)).Length != messageTypes.Count)
00949                                                         throw new Exception("There are message types which exist in Enum Message.MessageType but does not exist in DB. The running DB is not up to date with respect to the ASP server.");
00950                                         }
00951                                 }
00952                         }
00953 
00954                         return messageTypes;
00955                 }
00961                 static int GetValidationStatusIDByValidationStatus(Message.ValidationStatus validationStatus)
00962                 {
00963                         return GetValidationStatuses()[validationStatus].ID;
00964                 }
00965 
00966                 static string GetSelectValidationString(Table table, int rowID)
00967                 {
00968                         string sqlString = "";
00969 
00970                         sqlString = string.Format(
00971                                         "SELECT * FROM [{0}] WHERE [{1}] = {2}"
00972                                         , table.ValidationTableName, table.ValidationPrimaryKeyFieldName, rowID);
00973 
00974                         return sqlString;
00975                 }
00976 
00977                 static string GetSelectString(Table table, int rowID)
00978                 {
00979                         string sqlString = "";
00980 
00981                         sqlString = string.Format(
00982                                         "SELECT * FROM [{0}] WHERE [{1}] = {2}"
00983                                         , table.Name, table.PrimaryKeyFieldName, rowID);
00984 
00985                         return sqlString;
00986                 }
00996                 static SqlDataAdapter GetDataAdapter(string sqlString, DataSet dataSet)
00997                 {
00998                         SqlDataAdapter dataAdapter = new SqlDataAdapter(sqlString, DataAccessUtilities.ConnectionString);
00999                         SqlCommandBuilder builder = new SqlCommandBuilder(dataAdapter);
01000 
01001                         // Fill DataSet
01002                         dataAdapter.Fill(dataSet);
01003 
01004                         return dataAdapter;
01005                 }
01006 
01007                 static void InsertMultilookupValues(Table table, DataRow row, List<FieldData> rowValues)
01008                 {
01009                         using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
01010                         {
01011                                 sqlConnection.Open();
01012 
01013                                 using (SqlCommand sqlCommand = new SqlCommand(string.Empty, sqlConnection))
01014                                 {
01015                                         sqlCommand.CommandType = System.Data.CommandType.Text;
01016                                         foreach (FieldData fieldData in rowValues)
01017                                         {
01018                                                 if (fieldData.MultiLookupToInsert != null
01019                                                         && fieldData.MultiLookupToInsert.Count != 0)
01020                                                 {
01021                                                         foreach (KeyValuePair<int, string> kvp in fieldData.MultiLookupToInsert)
01022                                                         {
01023                                                                 string sqlString;
01024 
01025                                                                 sqlString = string.Format(
01026                                                                                 "INSERT [{0}]"
01027                                                                                         + " ([{0}].[{1}], [{0}].[{2}])"
01028                                                                                         + " VALUES "
01029                                                                                         + "({3}, {4})"
01030                                                                                 , table.Name + " " + fieldData.Field.RelatedTable.Name
01031                                                                                 , table.MultipleLookupForeignKey
01032                                                                                 , fieldData.Field.ForeignKeyFieldName
01033                                                                                 , row[table.PrimaryKeyFieldName]
01034                                                                                 , kvp.Key
01035                                                                                 );
01036 
01037                                                                 sqlCommand.CommandText = sqlString;
01038                                                                 sqlCommand.ExecuteNonQuery();
01039                                                         }
01040                                                 }
01041                                         }
01042                                 }
01043                         }
01044                 }
01045 
01046                 static void DeleteMultilookupValues(Table table, DataRow row, List<FieldData> rowValues)
01047                 {
01048                         using (SqlConnection sqlConnection = new SqlConnection(DataAccessUtilities.ConnectionString))
01049                         {
01050                                 sqlConnection.Open();
01051 
01052                                 using (SqlCommand sqlCommand = new SqlCommand(string.Empty, sqlConnection))
01053                                 {
01054                                         sqlCommand.CommandType = System.Data.CommandType.Text;
01055                                         foreach (FieldData fieldData in rowValues)
01056                                         {
01057                                                 if (fieldData.MultiLookupToDelete != null
01058                                                         && fieldData.MultiLookupToDelete.Count != 0)
01059                                                 {
01060                                                         foreach (KeyValuePair<int, string> kvp in fieldData.MultiLookupToDelete)
01061                                                         {
01062                                                                 string sqlString;
01063 
01064                                                                 sqlString = string.Format(
01065                                                                                 "DELETE FROM [{0}]"
01066                                                                                         + " WHERE [{0}].[{1}] = {3} AND [{0}].[{2}] = {4}"
01067                                                                                 , table.Name + " " + fieldData.Field.RelatedTable.Name
01068                                                                                 , table.MultipleLookupForeignKey
01069                                                                                 , fieldData.Field.ForeignKeyFieldName
01070                                                                                 , row[table.PrimaryKeyFieldName]
01071                                                                                 , kvp.Key
01072                                                                                 );
01073 
01074                                                                 sqlCommand.CommandText = sqlString;
01075                                                                 sqlCommand.ExecuteNonQuery();
01076                                                         }
01077                                                 }
01078                                         }
01079                                 }
01080                         }
01081                 }
01082 
01083                 static void FillDataSetFromValidationDataSet(List<FieldData> rowValues, List<FieldData> validationRowValues
01084                         , DataSet dataSet, DataSet validationDataSet, ref bool isInsertionNeeded, ref bool isDeletionNeeded)
01085                 {
01086                         isInsertionNeeded = false;
01087                         isDeletionNeeded = false;
01088 
01089                         int i = 0;
01090                         foreach (FieldData fieldData in rowValues)
01091                         {
01092 
01093                                 if (fieldData.Field.Type != Field.FieldType.MultipleLookup
01094                                         && fieldData.Field.Type != Field.FieldType.SingleLookup
01095                                         && fieldData.Field.Type != Field.FieldType.Label)
01096                                 {
01097                                         dataSet.Tables[0].Rows[0][fieldData.Field.Name] =
01098                                                 validationDataSet.Tables[0].Rows[0][fieldData.Field.Name];
01099                                 }
01100 
01101                                 if (fieldData.Field.Type == Field.FieldType.SingleLookup
01102                                         || fieldData.Field.Type == Field.FieldType.LookupPlusIntegerValue
01103                                         || fieldData.Field.Type == Field.FieldType.LookupPlusScientificValue)
01104                                 {
01105                                         dataSet.Tables[0].Rows[0][fieldData.Field.ForeignKeyFieldName] =
01106                                                 validationDataSet.Tables[0].Rows[0][fieldData.Field.ForeignKeyFieldName];
01107                                 }
01108 
01109                                 if (fieldData.Field.Type == Field.FieldType.MultipleLookup)
01110                                 {
01111                                         FieldData validationFieldData =
01112                                                 validationRowValues[i];
01113 
01114                                         fieldData.NewMultiLookupValues = validationFieldData.SelectedMultiLookupValues;
01115 
01116                                         if (fieldData.MultiLookupToInsert == null)
01117                                                 fieldData.MultiLookupToInsert = new Dictionary<int, string>();
01118                                         else
01119                                                 fieldData.MultiLookupToInsert.Clear();
01120 
01121                                         foreach (KeyValuePair<int, string> kvp in fieldData.NewMultiLookupValues)
01122                                         {
01123                                                 if (!fieldData.SelectedMultiLookupValues.ContainsKey(kvp.Key))
01124                                                 {
01125                                                         fieldData.MultiLookupToInsert.Add(kvp.Key, kvp.Value);
01126                                                         isInsertionNeeded = true;
01127                                                 }
01128                                         }
01129 
01130                                         if (fieldData.MultiLookupToDelete == null)
01131                                                 fieldData.MultiLookupToDelete = new Dictionary<int, string>();
01132                                         else
01133                                                 fieldData.MultiLookupToDelete.Clear();
01134 
01135                                         if (fieldData.NewMultiLookupValues == null)
01136                                                 fieldData.NewMultiLookupValues = new Dictionary<int, string>();
01137 
01138                                         foreach (KeyValuePair<int, string> kvp in fieldData.SelectedMultiLookupValues)
01139                                         {
01140                                                 if (!fieldData.NewMultiLookupValues.ContainsKey(kvp.Key))
01141                                                 {
01142                                                         fieldData.MultiLookupToDelete.Add(kvp.Key, kvp.Value);
01143                                                         isDeletionNeeded = true;
01144                                                 }
01145                                         }
01146                                 }
01147                                 i++;
01148                         }
01149 
01150                         dataSet.Tables[0].Rows[0]["RAIS_TIME_STAMP"] =
01151                                 validationDataSet.Tables[0].Rows[0]["RAIS_TIME_STAMP"];
01152                 }
01153                 #endregion
01154         }
01155 }
01156